home *** CD-ROM | disk | FTP | other *** search
/ Enter 2004 January / enter-2004-01.iso / files / maxima-5.9.0.exe / {app} / share / maxima / 5.9.0 / src / ode2.lisp < prev    next >
Encoding:
Text File  |  2003-02-09  |  51.1 KB  |  1,558 lines
  1. ;;; -*-  Mode: Lisp; Package: Maxima; Syntax: Common-Lisp; Base: 10 -*- ;;;; 
  2. ;;;Translated on: 7/18/85 13:12:45;;Maxima System version 2
  3. ;;** Variable settings were **
  4. (in-package "MAXIMA")
  5.  
  6. ;;TRANSCOMPILE:FALSE;
  7. ;;TR_SEMICOMPILE:FALSE;
  8. ;;TRANSLATE_FAST_ARRAYS:TRUE;
  9. ;;TR_WARN_UNDECLARED:COMPILE;
  10. ;;TR_WARN_MEVAL:COMPFILE;
  11. ;;TR_WARN_FEXPR:COMPFILE;
  12. ;;TR_WARN_MODE:ALL;
  13. ;;TR_WARN_UNDEFINED_VARIABLE:ALL;
  14. ;;TR_FUNCTION_CALL_DEFAULT:GENERAL;
  15. ;;TR_ARRAY_AS_REF:TRUE;
  16. ;;TR_NUMER:FALSE;
  17. ;;DEFINE_VARIABLE:FALSE;
  18.  
  19.  
  20.  
  21.  
  22.  
  23. NIL
  24. (EVAL-WHEN (COMPILE LOAD EVAL) (MEVAL* '(($DECLARE) $PT $SPECIAL $YP 
  25.                                              $SPECIAL $YOLD $SPECIAL $%Q%
  26.                          $SPECIAL $YNEW
  27.                                              $SPECIAL $X $SPECIAL $Y $SPECIAL 
  28.                                              $METHOD $SPECIAL $%F% $SPECIAL $%G%
  29.                                              $SPECIAL $MSG1 $SPECIAL $MSG2 
  30.                                              $SPECIAL $INTFACTOR $SPECIAL 
  31.                                              $ODEINDEX $SPECIAL $SINGSOLVE 
  32.                                              $SPECIAL)))
  33. #+symbolics  ;;above doesn't affect compiler for some reasons
  34. (declare (special $PT  $YP                                          $YOLD  $%Q% 
  35.                                               $X  $Y  
  36.                                              $METHOD  $%F%  $%G%
  37.                                               $MSG1  $MSG2 
  38.                                               $INTFACTOR  
  39.                                              $ODEINDEX  $SINGSOLVE ))
  40.  
  41.  
  42. (EVAL-WHEN (COMPILE EVAL LOAD)
  43.  (DEFPROP $ODE2 T TRANSLATED)
  44.  (ADD2LNC '$ODE2 $PROPS)
  45.  (DEFMTRFUN
  46.   ($ODE2 $ANY MDEFINE NIL NIL)
  47.   ($EQ $YOLD $X)
  48.   NIL
  49.   ((LAMBDA
  50.     ($DERIVSUBST $YNEW)
  51.     NIL
  52.     (SIMPLIFY
  53.      ($SUBSTITUTE
  54.       (TRD-MSYMEVAL $YOLD '$YOLD)
  55.       $YNEW
  56.       (SIMPLIFY ($ODE2A (SIMPLIFY ($SUBSTITUTE $YNEW
  57.                                                (TRD-MSYMEVAL $YOLD
  58.                                                              '$YOLD)
  59.                                                $EQ))
  60.                         $YNEW
  61.                         (TRD-MSYMEVAL $X '$X))))))
  62.    NIL
  63.    '$YNEW)))
  64. (EVAL-WHEN (COMPILE EVAL LOAD)
  65.  (DEFPROP $ODE2A T TRANSLATED)
  66.  (ADD2LNC '$ODE2A $PROPS)
  67.  (DEFMTRFUN
  68.   ($ODE2A $ANY MDEFINE NIL NIL)
  69.   ($EQ $Y $X)
  70.   NIL
  71.   ((LAMBDA
  72.     ($DE $A1 $A2 $A3 $A4 $%Q% $MSG)
  73.     NIL
  74.     (PROG
  75.      NIL
  76.      (SETQ $INTFACTOR NIL)
  77.      (SETQ $METHOD '$NONE)
  78.      (COND (($FREEOF (SIMPLIFY `((%DERIVATIVE) ,(TRD-MSYMEVAL $Y '$Y) ,
  79.                                  (TRD-MSYMEVAL $X '$X) 2))
  80.                      $EQ)
  81.             (COND (($FTEST (SIMPLIFY ($ODE1A $EQ
  82.                                              (TRD-MSYMEVAL $Y '$Y)
  83.                                              (TRD-MSYMEVAL $X '$X))))
  84.                    (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  85.                   (T (RETURN NIL)))))
  86.      (COND
  87.       ((NOT
  88.         (LIKE
  89.          (SIMPLIFY
  90.           ($DERIVDEGREE
  91.            (SETQ $DE (SIMPLIFY ($DESIMP (ADD* ($LHS $EQ)
  92.                                               (*MMINUS ($RHS $EQ))))))
  93.            (TRD-MSYMEVAL $Y '$Y)
  94.            (TRD-MSYMEVAL $X '$X)))
  95.          2))
  96.        (RETURN ($FAILURE (TRD-MSYMEVAL $MSG '$MSG) $EQ))))
  97.      (SETQ $A1 (SIMPLIFY ($COEFF $DE
  98.                                  (SIMPLIFY `((%DERIVATIVE) ,
  99.                                              (TRD-MSYMEVAL $Y '$Y) ,
  100.                                              (TRD-MSYMEVAL $X '$X) 2)))))
  101.      (SETQ $A2 (SIMPLIFY ($COEFF $DE
  102.                                  (SIMPLIFY `((%DERIVATIVE) ,
  103.                                              (TRD-MSYMEVAL $Y '$Y) ,
  104.                                              (TRD-MSYMEVAL $X '$X))))))
  105.      (SETQ $A3 (SIMPLIFY ($COEFF $DE (TRD-MSYMEVAL $Y '$Y))))
  106.      (SETQ
  107.       $A4
  108.       (SIMPLIFY
  109.        ($EXPAND
  110.         (ADD* $DE
  111.               (*MMINUS (MUL* $A1
  112.                              (SIMPLIFY `((%DERIVATIVE) ,
  113.                                          (TRD-MSYMEVAL $Y '$Y) ,
  114.                                          (TRD-MSYMEVAL $X '$X) 2))))
  115.               (MUL* (*MMINUS $A2)
  116.                     (SIMPLIFY `((%DERIVATIVE) ,(TRD-MSYMEVAL $Y '$Y) ,
  117.                                 (TRD-MSYMEVAL $X '$X))))
  118.               (MUL* (*MMINUS $A3) (TRD-MSYMEVAL $Y '$Y))))))
  119.      (COND ((AND ($PR2 $A1)
  120.                  ($PR2 $A2)
  121.                  ($PR2 $A3)
  122.                  ($PR2 $A4)
  123.                  ($FTEST (SIMPLIFY ($HOM2 $A1 $A2 $A3))))
  124.             (COND ((LIKE $A4 0)
  125.                    (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  126.                   (T (RETURN (SIMPLIFY ($VARP (TRD-MSYMEVAL $%Q% '$%Q%)
  127.                                               (DIV (*MMINUS $A4) $A1))))))))
  128.      (RETURN (COND (($FTEST (SIMPLIFY ($REDUCE $DE)))
  129.                     (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  130.                    (T (RETURN NIL))))))
  131.    '$DE
  132.    '$A1
  133.    '$A2
  134.    '$A3
  135.    '$A4
  136.    '$%Q%
  137.    '$MSG1)))
  138. (EVAL-WHEN (COMPILE EVAL LOAD)
  139.  (DEFPROP $ODE1A T TRANSLATED)
  140.  (ADD2LNC '$ODE1A $PROPS)
  141.  (DEFMTRFUN
  142.   ($ODE1A $ANY MDEFINE NIL NIL)
  143.   ($EQ $Y $X)
  144.   NIL
  145.   ((LAMBDA
  146.     ($DE $DES)
  147.     NIL
  148.     (PROG
  149.      NIL
  150.      (COND
  151.       ((NOT
  152.         (LIKE
  153.          (SIMPLIFY
  154.           ($DERIVDEGREE
  155.            (SETQ $DE (SIMPLIFY ($EXPAND (ADD* ($LHS $EQ)
  156.                                               (*MMINUS ($RHS $EQ))))))
  157.            (TRD-MSYMEVAL $Y '$Y)
  158.            (TRD-MSYMEVAL $X '$X)))
  159.          1))
  160.        (RETURN ($FAILURE (TRD-MSYMEVAL $MSG1 '$MSG1) $EQ))))
  161.      (COND ((LIKE (SIMPLIFY ($LINEAR2 $DE
  162.                                       (SIMPLIFY `((%DERIVATIVE) ,
  163.                                                   (TRD-MSYMEVAL $Y '$Y) ,
  164.                                                   (TRD-MSYMEVAL $X '$X)))))
  165.                   NIL)
  166.             (RETURN ($FAILURE (TRD-MSYMEVAL $MSG2 '$MSG2) $EQ))))
  167.      (SETQ $DES (SIMPLIFY ($DESIMP $DE)))
  168.      (SETQ $DE (SIMPLIFY ($SOLVE1 $DES
  169.                                   (SIMPLIFY `((%DERIVATIVE) ,
  170.                                               (TRD-MSYMEVAL $Y '$Y) ,
  171.                                               (TRD-MSYMEVAL $X '$X))))))
  172.      (COND (($FTEST (SIMPLIFY ($SOLVELNR $DE)))
  173.             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  174.      (COND (($FTEST (SIMPLIFY ($SEPARABLE $DE)))
  175.             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  176.      (COND (($FTEST (SIMPLIFY ($INTEGFACTOR (TRD-MSYMEVAL $%G% '$%G%)
  177.                                             (TRD-MSYMEVAL $%F% '$%F%))))
  178.             (RETURN (SIMPLIFY ($EXACT (MUL* (TRD-MSYMEVAL $%Q% '$%Q%)
  179.                                             (TRD-MSYMEVAL $%G% '$%G%))
  180.                                       (MUL* (TRD-MSYMEVAL $%Q% '$%Q%)
  181.                                             (TRD-MSYMEVAL $%F% '$%F%)))))))
  182.      (COND ((LIKE (SIMPLIFY ($LINEAR2 $DES
  183.                                       (SIMPLIFY `((%DERIVATIVE) ,
  184.                                                   (TRD-MSYMEVAL $Y '$Y) ,
  185.                                                   (TRD-MSYMEVAL $X '$X)))))
  186.                   NIL)
  187.             (RETURN ($FAILURE (TRD-MSYMEVAL $MSG2 '$MSG2) $EQ))))
  188.      (COND (($FTEST (SIMPLIFY ($INTEGFACTOR (TRD-MSYMEVAL $%G% '$%G%)
  189.                                             (TRD-MSYMEVAL $%F% '$%F%))))
  190.             (RETURN (SIMPLIFY ($EXACT (MUL* (TRD-MSYMEVAL $%Q% '$%Q%)
  191.                                             (TRD-MSYMEVAL $%G% '$%G%))
  192.                                       (MUL* (TRD-MSYMEVAL $%Q% '$%Q%)
  193.                                             (TRD-MSYMEVAL $%F% '$%F%)))))))
  194.      (COND (($FTEST (SIMPLIFY ($SOLVEHOM $DE)))
  195.             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  196.      (COND (($FTEST (SIMPLIFY ($SOLVEBERNOULLI $DE)))
  197.             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  198.      (RETURN (COND (($FTEST (SIMPLIFY ($GENHOM $DE)))
  199.                     (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  200.                    (T (RETURN NIL))))))
  201.    '$DE
  202.    '$DES)))
  203. (EVAL-WHEN (COMPILE EVAL LOAD)
  204.  (DEFPROP $DESIMP T TRANSLATED)
  205.  (ADD2LNC '$DESIMP $PROPS)
  206.  (DEFMTRFUN
  207.   ($DESIMP $ANY MDEFINE NIL NIL)
  208.   ($EQ)
  209.   NIL
  210.   ((LAMBDA
  211.     ($INFLAG)
  212.     NIL
  213.     (PROG
  214.      NIL
  215.      (SETQ $EQ (SIMPLIFY ($FACTOR $EQ)))
  216.      (COND ((OR ($ATOM $EQ)
  217.                 (NOT (LIKE (SIMPLIFY ($INPART $EQ 0)) '&*)))
  218.             (RETURN (SIMPLIFY ($EXPAND $EQ)))))
  219.      (SETQ
  220.       $EQ
  221.       (SIMPLIFY
  222.        (MAP1
  223.         (GETOPR (M-TLAMBDA ($U)
  224.                            NIL
  225.                            (COND (($FREEOF (SIMPLIFY ($NOUNIFY '$DIFF))
  226.                                            $U)
  227.                                   1)
  228.                                  (T $U))))
  229.         $EQ)))
  230.      (RETURN (SIMPLIFY ($EXPAND $EQ)))))
  231.    T)))
  232. (EVAL-WHEN (COMPILE EVAL LOAD)
  233.        (DEFPROP $PR2 T TRANSLATED)
  234.        (ADD2LNC '$PR2 $PROPS)
  235.        (DEFMTRFUN ($PR2 $BOOLEAN MDEFINE NIL NIL)
  236.                   ($%F%)
  237.                   NIL
  238.                   ($FREEOF (TRD-MSYMEVAL $Y '$Y)
  239.                            (SIMPLIFY `((%DERIVATIVE) ,(TRD-MSYMEVAL $Y '$Y) ,
  240.                                        (TRD-MSYMEVAL $X '$X)))
  241.                            (SIMPLIFY `((%DERIVATIVE) ,(TRD-MSYMEVAL $Y '$Y) ,
  242.                                        (TRD-MSYMEVAL $X '$X) 2))
  243.                            (TRD-MSYMEVAL $%F% '$%F%))))
  244. (EVAL-WHEN (COMPILE EVAL LOAD)
  245.        (DEFPROP $FTEST T TRANSLATED)
  246.        (ADD2LNC '$FTEST $PROPS)
  247.        (DEFMTRFUN ($FTEST $BOOLEAN MDEFINE NIL NIL)
  248.                   ($CALL)
  249.                   NIL
  250.                   (NOT (LIKE (SETQ $%Q% $CALL)
  251.                              NIL))))
  252. (EVAL-WHEN (COMPILE EVAL LOAD)
  253.  (DEFPROP $SOLVE1 T TRANSLATED)
  254.  (ADD2LNC '$SOLVE1 $PROPS)
  255.  (DEFMTRFUN ($SOLVE1 $ANY MDEFINE NIL NIL)
  256.             ($EQ $Y)
  257.             NIL
  258.             ((LAMBDA ($PROGRAMMODE)
  259.                NIL
  260.                (SIMPLIFY ($FIRST (SIMPLIFY ($SOLVE $EQ
  261.                                                    (TRD-MSYMEVAL $Y '$Y))))))
  262.              T)))
  263. (EVAL-WHEN (COMPILE EVAL LOAD)
  264.  (DEFPROP $LINEAR2 T TRANSLATED)
  265.  (ADD2LNC '$LINEAR2 $PROPS)
  266.  (DEFMTRFUN
  267.   ($LINEAR2 $ANY MDEFINE NIL NIL)
  268.   ($EXPR $X)
  269.   NIL
  270.   ((LAMBDA
  271.     NIL
  272.     NIL
  273.     (PROG
  274.      NIL
  275.      (SETQ $%F% (SIMPLIFY ($RATCOEF $EXPR (TRD-MSYMEVAL $X '$X))))
  276.      (COND ((NOT ($FREEOF (TRD-MSYMEVAL $X '$X) (TRD-MSYMEVAL $%F% '$%F%)))
  277.             (RETURN NIL)))
  278.      (SETQ
  279.       $%G%
  280.       (SIMPLIFY ($RATSIMP (ADD* $EXPR
  281.                                 (*MMINUS (MUL* (TRD-MSYMEVAL $%F%
  282.                                                              '$%F%)
  283.                                                (TRD-MSYMEVAL $X '$X)))))))
  284.      (RETURN ($FREEOF (TRD-MSYMEVAL $X '$X) (TRD-MSYMEVAL $%G% '$%G%))))))))
  285. (EVAL-WHEN (COMPILE EVAL LOAD)
  286.  (DEFPROP $SOLVELNR T TRANSLATED)
  287.  (ADD2LNC '$SOLVELNR $PROPS)
  288.  (DEFMTRFUN
  289.   ($SOLVELNR $ANY MDEFINE NIL NIL)
  290.   ($EQ)
  291.   NIL
  292.   ((LAMBDA
  293.     ($%F% $%G% $W $%C)
  294.     NIL
  295.     (PROG
  296.      NIL
  297.      (COND ((LIKE (SIMPLIFY ($LINEAR2 ($RHS $EQ) (TRD-MSYMEVAL $Y '$Y)))
  298.                   NIL)
  299.             (RETURN NIL)))
  300.      (SETQ
  301.       $W
  302.       (SIMPLIFY ($EXP (SIMPLIFY ($INTEGRATE (TRD-MSYMEVAL $%F% '$%F%)
  303.                                             (TRD-MSYMEVAL $X '$X))))))
  304.      (SETQ $METHOD '$LINEAR)
  305.      (RETURN
  306.       (SIMPLIFY
  307.        (LIST
  308.         '(MEQUAL)
  309.         (TRD-MSYMEVAL $Y '$Y)
  310.         (MUL* $W
  311.               (ADD* (SIMPLIFY ($INTEGRATE (DIV (TRD-MSYMEVAL $%G%
  312.                                                              '$%G%)
  313.                                                $W)
  314.                                           (TRD-MSYMEVAL $X '$X)))
  315.                     $%C)))))))
  316.    '$%F%
  317.    '$%G%
  318.    '$W
  319.    '$%C)))
  320. (EVAL-WHEN (COMPILE EVAL LOAD)
  321.  (DEFPROP $SEPARABLE T TRANSLATED)
  322.  (ADD2LNC '$SEPARABLE $PROPS)
  323.  (DEFMTRFUN
  324.   ($SEPARABLE $ANY MDEFINE NIL NIL)
  325.   ($EQ)
  326.   NIL
  327.   ((LAMBDA
  328.     ($XPART $YPART $FLAG $INFLAG $%C)
  329.     NIL
  330.     (PROG
  331.      NIL
  332.      (SETQ $EQ (SIMPLIFY ($FACTOR ($RHS $EQ))))
  333.      (COND ((OR ($ATOM $EQ)
  334.                 (NOT (LIKE (SIMPLIFY ($INPART $EQ 0)) '&*)))
  335.             (SETQ $EQ (LIST '(MLIST) $EQ))))
  336.      (DO (($U)
  337.           (MDO (CDR $EQ) (CDR MDO)))
  338.          ((NULL MDO) '$DONE)
  339.        (SETQ $U (CAR MDO))
  340.        (COND (($FREEOF (TRD-MSYMEVAL $X '$X) $U)
  341.               (SETQ $YPART ($CONS $U $YPART)))
  342.              (($FREEOF (TRD-MSYMEVAL $Y '$Y) $U)
  343.               (SETQ $XPART ($CONS $U $XPART)))
  344.              (T (RETURN (SETQ $FLAG T)))))
  345.      (COND ((LIKE $FLAG T)
  346.             (RETURN NIL)))
  347.      (COND ((LIKE $XPART '((MLIST)))
  348.             (SETQ $XPART 1))
  349.            (T (SETQ $XPART (SIMPLIFY (MAPPLY-TR '&* $XPART)))))
  350.      (COND ((LIKE $YPART '((MLIST)))
  351.             (SETQ $YPART 1))
  352.            (T (SETQ $YPART (SIMPLIFY (MAPPLY-TR '&* $YPART)))))
  353.      (SETQ $METHOD '$SEPARABLE)
  354.      (RETURN
  355.       (SIMPLIFY
  356.        (LIST
  357.         '(MEQUAL)
  358.         (SIMPLIFY ($RATSIMP (SIMPLIFY ($INTEGRATE (DIV 1 $YPART)
  359.                                                   (TRD-MSYMEVAL $Y
  360.                                                                 '$Y)))))
  361.         (ADD*
  362.          (SIMPLIFY ($RATSIMP (SIMPLIFY ($INTEGRATE $XPART
  363.                                                    (TRD-MSYMEVAL $X
  364.                                                                  '$X)))))
  365.          $%C))))))
  366.    '((MLIST))
  367.    '((MLIST))
  368.    NIL
  369.    T
  370.    '$%C)))
  371. (EVAL-WHEN (COMPILE EVAL LOAD)
  372.  (DEFPROP $INTEGFACTOR T TRANSLATED)
  373.  (ADD2LNC '$INTEGFACTOR $PROPS)
  374.  (DEFMTRFUN
  375.   ($INTEGFACTOR $ANY MDEFINE NIL NIL)
  376.   ($M $N)
  377.   NIL
  378.   ((LAMBDA
  379.     ($B1 $B2 $DMDX $DMDY $DNDX $DNDY $DD $%E_TO_NUMLOG)
  380.     NIL
  381.     (PROG
  382.      NIL
  383.      (SETQ $DMDY (SIMPLIFY ($RATSIMP (SIMPLIFY ($DIFF $M
  384.                                                       (TRD-MSYMEVAL $Y
  385.                                                                     '$Y))))))
  386.      (SETQ $DNDX (SIMPLIFY ($RATSIMP (SIMPLIFY ($DIFF $N
  387.                                                       (TRD-MSYMEVAL $X
  388.                                                                     '$X))))))
  389.      (COND ((LIKE (SETQ $DD (ADD* $DMDY (*MMINUS $DNDX)))
  390.                   0)
  391.             (RETURN 1)))
  392.      (SETQ $DMDX (SIMPLIFY ($RATSIMP (SIMPLIFY ($DIFF $M
  393.                                                       (TRD-MSYMEVAL $X
  394.                                                                     '$X))))))
  395.      (SETQ $DNDY (SIMPLIFY ($RATSIMP (SIMPLIFY ($DIFF $N
  396.                                                       (TRD-MSYMEVAL $Y
  397.                                                                     '$Y))))))
  398.      (COND ((AND (LIKE (ADD* $DMDX (*MMINUS $DNDY)) 0)
  399.                  (LIKE (ADD* $DMDY $DNDX) 0))
  400.             (RETURN (DIV 1 (ADD* (POWER $M 2) (POWER $N 2))))))
  401.      (COND
  402.       (($FREEOF (TRD-MSYMEVAL $Y '$Y)
  403.                 (SETQ $B1 (SIMPLIFY ($RATSIMP (DIV $DD $N)))))
  404.        (RETURN
  405.         (SIMPLIFY ($EXP (SIMPLIFY ($INTEGRATE $B1
  406.                                               (TRD-MSYMEVAL $X '$X))))))))
  407.      (RETURN
  408.       (COND
  409.        (($FREEOF (TRD-MSYMEVAL $X '$X)
  410.                  (SETQ $B2 (SIMPLIFY ($RATSIMP (DIV $DD $M)))))
  411.         (RETURN
  412.          (SIMPLIFY ($EXP (SIMPLIFY ($INTEGRATE (*MMINUS $B2)
  413.                                                (TRD-MSYMEVAL $Y '$Y)))))))
  414.        (T (RETURN NIL))))))
  415.    '$B1
  416.    '$B2
  417.    '$DMDX
  418.    '$DMDY
  419.    '$DNDX
  420.    '$DNDY
  421.    '$DD
  422.    T)))
  423. (EVAL-WHEN (COMPILE EVAL LOAD)
  424.  (DEFPROP $EXACT T TRANSLATED)
  425.  (ADD2LNC '$EXACT $PROPS)
  426.  (DEFMTRFUN
  427.   ($EXACT $ANY MDEFINE NIL NIL)
  428.   ($M $N)
  429.   NIL
  430.   ((LAMBDA
  431.     ($A $YNEW $%C)
  432.     NIL
  433.     (PROG
  434.      NIL
  435.      (SETQ $INTFACTOR (SIMPLIFY ($SUBSTITUTE (TRD-MSYMEVAL $YOLD '$YOLD)
  436.                                              $YNEW
  437.                                              (TRD-MSYMEVAL $%Q% '$%Q%))))
  438.      (SETQ $A (SIMPLIFY ($INTEGRATE (SIMPLIFY ($RATSIMP $M))
  439.                                     (TRD-MSYMEVAL $X '$X))))
  440.      (SETQ $METHOD '$EXACT)
  441.      (RETURN
  442.       (SIMPLIFY
  443.        (LIST
  444.         '(MEQUAL)
  445.         (SIMPLIFY
  446.          ($RATSIMP
  447.           (ADD*
  448.            $A
  449.            (SIMPLIFY
  450.             ($INTEGRATE
  451.              (SIMPLIFY
  452.               ($RATSIMP
  453.                (ADD*
  454.                 $N
  455.                 (*MMINUS (SIMPLIFY ($DIFF $A
  456.                                           (TRD-MSYMEVAL $Y '$Y)))))))
  457.              (TRD-MSYMEVAL $Y '$Y))))))
  458.         $%C)))))
  459.    '$A
  460.    '$YNEW
  461.    '$%C)))
  462. (EVAL-WHEN (COMPILE EVAL LOAD)
  463.  (DEFPROP $SOLVEHOM T TRANSLATED)
  464.  (ADD2LNC '$SOLVEHOM $PROPS)
  465.  (DEFMTRFUN
  466.   ($SOLVEHOM $ANY MDEFINE NIL NIL)
  467.   ($EQ)
  468.   NIL
  469.   ((LAMBDA
  470.     ($QQ $A1 $A2 $%C)
  471.     NIL
  472.     (PROG
  473.      NIL
  474.      (SETQ
  475.       $A1
  476.       (SIMPLIFY ($RATSIMP (SIMPLIFY ($SUBSTITUTE (MUL* (TRD-MSYMEVAL $X
  477.                                                                      '$X)
  478.                                                        $QQ)
  479.                                                  (TRD-MSYMEVAL $Y '$Y)
  480.                                                  ($RHS $EQ))))))
  481.      (COND ((NOT ($FREEOF (TRD-MSYMEVAL $X '$X) $A1))
  482.             (RETURN NIL)))
  483.      (SETQ
  484.       $A2
  485.       (SIMPLIFY
  486.        ($RATSIMP
  487.         (SIMPLIFY
  488.          ($SUBSTITUTE (DIV (TRD-MSYMEVAL $Y '$Y) (TRD-MSYMEVAL $X '$X))
  489.                       $QQ
  490.                       (SIMPLIFY ($INTEGRATE (DIV 1
  491.                                                  (ADD* $A1
  492.                                                        (*MMINUS $QQ)))
  493.                                             $QQ)))))))
  494.      (SETQ $METHOD '$HOMOGENEOUS)
  495.      (RETURN (SIMPLIFY (LIST '(MEQUAL)
  496.                              (MUL* $%C (TRD-MSYMEVAL $X '$X))
  497.                              (SIMPLIFY ($EXP $A2)))))))
  498.    '$QQ
  499.    '$A1
  500.    '$A2
  501.    '$%C)))
  502. (EVAL-WHEN (COMPILE EVAL LOAD)
  503.  (DEFPROP $SOLVEBERNOULLI T TRANSLATED)
  504.  (ADD2LNC '$SOLVEBERNOULLI $PROPS)
  505.  (DEFMTRFUN
  506.   ($SOLVEBERNOULLI $ANY MDEFINE NIL NIL)
  507.   ($EQ)
  508.   NIL
  509.   ((LAMBDA
  510.     ($A1 $A2 $N $%C)
  511.     NIL
  512.     (PROG
  513.      NIL
  514.      (SETQ $A1 (SIMPLIFY ($COEFF (SETQ $EQ (SIMPLIFY ($EXPAND ($RHS $EQ))))
  515.                                  (TRD-MSYMEVAL $Y '$Y)
  516.                                  1)))
  517.      (COND ((NOT ($FREEOF (TRD-MSYMEVAL $Y '$Y) $A1))
  518.             (RETURN NIL)))
  519.      (SETQ
  520.       $N
  521.       (SIMPLIFY
  522.        ($HIPOW
  523.         (SIMPLIFY ($RATSIMP (ADD* $EQ
  524.                                   (*MMINUS (MUL* $A1
  525.                                                  (TRD-MSYMEVAL $Y '$Y))))))
  526.         (TRD-MSYMEVAL $Y '$Y))))
  527.      (SETQ $A2 (SIMPLIFY ($COEFF $EQ (TRD-MSYMEVAL $Y '$Y) $N)))
  528.      (COND
  529.       ((OR
  530.         (NOT ($FREEOF (TRD-MSYMEVAL $Y '$Y) $A2))
  531.         (NOT ($FREEOF (TRD-MSYMEVAL $X '$X) (TRD-MSYMEVAL $Y '$Y) $N))
  532.         (LIKE $N 0)
  533.         (NOT
  534.          (LIKE
  535.           $EQ
  536.           (SIMPLIFY ($EXPAND (ADD* (MUL* $A1 (TRD-MSYMEVAL $Y '$Y))
  537.                                    (MUL* $A2
  538.                                          (POWER (TRD-MSYMEVAL $Y '$Y)
  539.                                                 $N))))))))
  540.        (RETURN NIL)))
  541.      (SETQ $A1 (SIMPLIFY ($INTEGRATE $A1 (TRD-MSYMEVAL $X '$X))))
  542.      (SETQ $METHOD '$BERNOULLI)
  543.      (SETQ $ODEINDEX $N)
  544.      (RETURN
  545.       (SIMPLIFY
  546.        (LIST
  547.         '(MEQUAL)
  548.         (TRD-MSYMEVAL $Y '$Y)
  549.         (MUL*
  550.          (SIMPLIFY ($EXP $A1))
  551.          (POWER
  552.           (ADD*
  553.            (MUL*
  554.             (ADD* 1 (*MMINUS $N))
  555.             (SIMPLIFY
  556.              ($INTEGRATE (MUL* $A2
  557.                                (SIMPLIFY ($EXP (MUL* (ADD* $N -1)
  558.                                                      $A1))))
  559.                          (TRD-MSYMEVAL $X '$X))))
  560.            $%C)
  561.           (DIV 1 (ADD* 1 (*MMINUS $N))))))))))
  562.    '$A1
  563.    '$A2
  564.    '$N
  565.    '$%C)))
  566. (EVAL-WHEN (COMPILE EVAL LOAD)
  567.  (DEFPROP $GENHOM T TRANSLATED)
  568.  (ADD2LNC '$GENHOM $PROPS)
  569.  (DEFMTRFUN
  570.   ($GENHOM $ANY MDEFINE NIL NIL)
  571.   ($EQ)
  572.   NIL
  573.   ((LAMBDA
  574.     ($%G% $U $N $A1 $A2 $A3 $%C)
  575.     NIL
  576.     (PROG
  577.      NIL
  578.      (SETQ $%G% (DIV (MUL* ($RHS $EQ) (TRD-MSYMEVAL $X '$X))
  579.                      (TRD-MSYMEVAL $Y '$Y)))
  580.      (SETQ
  581.       $N
  582.       (SIMPLIFY
  583.        ($RATSIMP (DIV (MUL* (TRD-MSYMEVAL $X '$X)
  584.                             (SIMPLIFY ($DIFF (TRD-MSYMEVAL $%G% '$%G%)
  585.                                              (TRD-MSYMEVAL $X '$X))))
  586.                       (MUL* (TRD-MSYMEVAL $Y '$Y)
  587.                             (SIMPLIFY ($DIFF (TRD-MSYMEVAL $%G% '$%G%)
  588.                                              (TRD-MSYMEVAL $Y '$Y))))))))
  589.      (COND ((NOT ($FREEOF (TRD-MSYMEVAL $X '$X) (TRD-MSYMEVAL $Y '$Y) $N))
  590.             (RETURN NIL)))
  591.      (SETQ
  592.       $A1
  593.       (SIMPLIFY
  594.        ($RATSIMP (SIMPLIFY ($SUBSTITUTE (DIV $U
  595.                                              (POWER (TRD-MSYMEVAL $X
  596.                                                                   '$X)
  597.                                                     $N))
  598.                                         (TRD-MSYMEVAL $Y '$Y)
  599.                                         (TRD-MSYMEVAL $%G% '$%G%))))))
  600.      (SETQ $A2 (SIMPLIFY ($INTEGRATE (DIV 1 (MUL* $U (ADD* $N $A1))) $U)))
  601.      (COND ((NOT ($FREEOF (SIMPLIFY ($NOUNIFY '$INTEGRATE)) $A2))
  602.             (RETURN NIL)))
  603.      (SETQ
  604.       $A3
  605.       (SIMPLIFY
  606.        ($RATSIMP (SIMPLIFY ($SUBSTITUTE (MUL* (TRD-MSYMEVAL $Y '$Y)
  607.                                               (POWER (TRD-MSYMEVAL $X
  608.                                                                    '$X)
  609.                                                      $N))
  610.                                         $U
  611.                                         $A2)))))
  612.      (SETQ $METHOD '$GENHOM)
  613.      (SETQ $ODEINDEX $N)
  614.      (RETURN (SIMPLIFY (LIST '(MEQUAL)
  615.                              (TRD-MSYMEVAL $X '$X)
  616.                              (MUL* $%C (SIMPLIFY ($EXP $A3))))))))
  617.    '$%G%
  618.    '$U
  619.    '$N
  620.    '$A1
  621.    '$A2
  622.    '$A3
  623.    '$%C)))
  624. (EVAL-WHEN (COMPILE EVAL LOAD)
  625.  (DEFPROP $HOM2 T TRANSLATED)
  626.  (ADD2LNC '$HOM2 $PROPS)
  627.  (DEFMTRFUN ($HOM2 $ANY MDEFINE NIL NIL)
  628.             ($A1 $A2 $A3)
  629.             NIL
  630.             ((LAMBDA ($AP $AQ $PT)
  631.                NIL
  632.                (PROG NIL
  633.                      (SETQ $AP (DIV $A2 $A1))
  634.                      (SETQ $AQ (DIV $A3 $A1))
  635.                      (COND (($FTEST (SIMPLIFY ($CC2 $AP
  636.                                                     $AQ
  637.                                                     (TRD-MSYMEVAL $Y '$Y)
  638.                                                     (TRD-MSYMEVAL $X '$X))))
  639.                             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  640.                      (COND (($FTEST (SIMPLIFY ($EXACT2 $A1 $A2 $A3)))
  641.                             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  642.                      (COND ((LIKE (SETQ $PT (SIMPLIFY ($PTTEST $AP)))
  643.                                   NIL)
  644.                             (GO $END)))
  645.                      (COND (($FTEST (SIMPLIFY ($EULER2 $AP $AQ)))
  646.                             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  647.                      (COND (($FTEST (SIMPLIFY ($BESSEL2 $AP $AQ)))
  648.                             (RETURN (TRD-MSYMEVAL $%Q% '$%Q%))))
  649.                 $END (RETURN (COND (($FTEST (SIMPLIFY ($XCC2 $AP $AQ)))
  650.                                     (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  651.                                    (T (RETURN NIL))))))
  652.              '$AP
  653.              '$AQ
  654.              '$PT)))
  655. (EVAL-WHEN (COMPILE EVAL LOAD)
  656.  (DEFPROP $CC2 T TRANSLATED)
  657.  (ADD2LNC '$CC2 $PROPS)
  658.  (DEFMTRFUN
  659.   ($CC2 $ANY MDEFINE NIL NIL)
  660.   ($%F% $%G% $Y $X)
  661.   NIL
  662.   ((LAMBDA
  663.     ($A $SIGN $RADEXPAND $ALPHA $ZERO $POS $YNEW $%K1 $%K2)
  664.     NIL
  665.     (PROG
  666.      NIL
  667.      (COND ((NOT (AND ($FREEOF (TRD-MSYMEVAL $X '$X)
  668.                                (TRD-MSYMEVAL $Y '$Y)
  669.                                (TRD-MSYMEVAL $%F% '$%F%))
  670.                       ($FREEOF (TRD-MSYMEVAL $X '$X)
  671.                                (TRD-MSYMEVAL $Y '$Y)
  672.                                (TRD-MSYMEVAL $%G% '$%G%))))
  673.             (RETURN NIL)))
  674.      (SETQ $METHOD '$CONSTCOEFF)
  675.      (SETQ $A (ADD* (POWER (TRD-MSYMEVAL $%F% '$%F%) 2)
  676.                     (*MMINUS (MUL* 4 (TRD-MSYMEVAL $%G% '$%G%)))))
  677.      (COND (($FREEOF '$%I $A)
  678.             (SETQ $SIGN (SIMPLIFY ($ASKSIGN $A))))
  679.            (T
  680.             (SETQ $RADEXPAND T)
  681.             (SETQ $SIGN '$PNZ)))
  682.      (COND
  683.       ((LIKE $SIGN $ZERO)
  684.        (RETURN
  685.         (SIMPLIFY
  686.          (LIST
  687.           '(MEQUAL)
  688.           (TRD-MSYMEVAL $Y '$Y)
  689.           (MUL*
  690.            (SIMPLIFY ($EXP (DIV (MUL* (*MMINUS (TRD-MSYMEVAL $%F%
  691.                                                              '$%F%))
  692.                                       (TRD-MSYMEVAL $X '$X))
  693.                                 2)))
  694.            (ADD* $%K1 (MUL* $%K2 (TRD-MSYMEVAL $X '$X)))))))))
  695.      (COND
  696.       ((LIKE $SIGN $POS)
  697.        (RETURN
  698.         (SIMPLIFY
  699.          (LIST
  700.           '(MEQUAL)
  701.           (TRD-MSYMEVAL $Y '$Y)
  702.           (ADD*
  703.            (MUL*
  704.             $%K1
  705.             (SIMPLIFY
  706.              ($EXP (DIV (MUL* (ADD* (*MMINUS (TRD-MSYMEVAL $%F%
  707.                                                            '$%F%))
  708.                                     (SIMPLIFY (LIST '(%SQRT) $A)))
  709.                               (TRD-MSYMEVAL $X '$X))
  710.                         2))))
  711.            (MUL*
  712.             $%K2
  713.             (SIMPLIFY
  714.              ($EXP
  715.               (DIV (MUL* (ADD* (*MMINUS (TRD-MSYMEVAL $%F% '$%F%))
  716.                                (*MMINUS (SIMPLIFY (LIST '(%SQRT)
  717.                                                         $A))))
  718.                          (TRD-MSYMEVAL $X '$X))
  719.                    2))))))))))
  720.      (SETQ $A (*MMINUS $A))
  721.      (SETQ $ALPHA (DIV (MUL* (TRD-MSYMEVAL $X '$X)
  722.                              (SIMPLIFY (LIST '(%SQRT) $A)))
  723.                        2))
  724.      (COND
  725.       ((LIKE (TRD-MSYMEVAL $EXPONENTIALIZE NIL) NIL)
  726.        (RETURN
  727.         (SIMPLIFY
  728.          (LIST
  729.           '(MEQUAL)
  730.           (TRD-MSYMEVAL $Y '$Y)
  731.           (MUL*
  732.            (SIMPLIFY ($EXP (DIV (MUL* (*MMINUS (TRD-MSYMEVAL $%F%
  733.                                                              '$%F%))
  734.                                       (TRD-MSYMEVAL $X '$X))
  735.                                 2)))
  736.            (ADD* (MUL* $%K1 (SIMPLIFY (LIST '(%SIN) $ALPHA)))
  737.                  (MUL* $%K2 (SIMPLIFY (LIST '(%COS) $ALPHA))))))))))
  738.      (RETURN
  739.       (SIMPLIFY
  740.        (LIST
  741.         '(MEQUAL)
  742.         (TRD-MSYMEVAL $Y '$Y)
  743.         (MUL* (SIMPLIFY ($EXP (DIV (MUL* (*MMINUS (TRD-MSYMEVAL $%F%
  744.                                                                 '$%F%))
  745.                                          (TRD-MSYMEVAL $X '$X))
  746.                                    2)))
  747.               (ADD* (MUL* $%K1 (SIMPLIFY ($EXP (MUL* '$%I $ALPHA))))
  748.                     (MUL* $%K2
  749.                           (SIMPLIFY ($EXP (MUL* (*MMINUS '$%I)
  750.                                                 $ALPHA)))))))))))
  751.    '$A
  752.    '$SIGN
  753.    '$ALL
  754.    '$ALPHA
  755.    '$ZERO
  756.    '$POS
  757.    '$YNEW
  758.    '$%K1
  759.    '$%K2)))
  760. (EVAL-WHEN (COMPILE EVAL LOAD)
  761.  (DEFPROP $EXACT2 T TRANSLATED)
  762.  (ADD2LNC '$EXACT2 $PROPS)
  763.  (DEFMTRFUN
  764.   ($EXACT2 $ANY MDEFINE NIL NIL)
  765.   ($A1 $A2 $A3)
  766.   NIL
  767.   ((LAMBDA
  768.     ($B1 $%K1 $%K2)
  769.     NIL
  770.     (PROG
  771.      NIL
  772.      (COND
  773.       ((LIKE
  774.         (SIMPLIFY
  775.          ($RATSIMP (ADD* (SIMPLIFY ($DIFF $A1 (TRD-MSYMEVAL $X '$X) 2))
  776.                          (*MMINUS (SIMPLIFY ($DIFF $A2
  777.                                                    (TRD-MSYMEVAL $X '$X))))
  778.                          $A3)))
  779.         0)
  780.        (SETQ
  781.         $B1
  782.         (SIMPLIFY
  783.          ($EXP
  784.           (*MMINUS
  785.            (SIMPLIFY
  786.             ($INTEGRATE
  787.              (SIMPLIFY
  788.               ($RATSIMP
  789.                (DIV
  790.                 (ADD*
  791.                  $A2
  792.                  (*MMINUS (SIMPLIFY ($DIFF $A1
  793.                                            (TRD-MSYMEVAL $X '$X)))))
  794.                 $A1)))
  795.              (TRD-MSYMEVAL $X '$X))))))))
  796.       (T (RETURN NIL)))
  797.      (SETQ $METHOD '$EXACT)
  798.      (RETURN
  799.       (SIMPLIFY
  800.        (LIST '(MEQUAL)
  801.              (TRD-MSYMEVAL $Y '$Y)
  802.              (ADD* (MUL* $%K1
  803.                          $B1
  804.                          (SIMPLIFY ($INTEGRATE (DIV 1 (MUL* $A1 $B1))
  805.                                                (TRD-MSYMEVAL $X '$X))))
  806.                    (MUL* $%K2 $B1)))))))
  807.    '$B1
  808.    '$%K1
  809.    '$%K2)))
  810. (EVAL-WHEN (COMPILE EVAL LOAD)
  811.  (DEFPROP $XCC2 T TRANSLATED)
  812.  (ADD2LNC '$XCC2 $PROPS)
  813.  (DEFMTRFUN
  814.   ($XCC2 $ANY MDEFINE NIL NIL)
  815.   ($AP $AQ)
  816.   NIL
  817.   ((LAMBDA
  818.     ($D $B1 $Z $RADEXPAND)
  819.     NIL
  820.     (PROG
  821.      NIL
  822.      (COND ((LIKE $AQ 0)
  823.             (RETURN NIL)))
  824.      (SETQ
  825.       $D
  826.       (SIMPLIFY ($RATSIMP (DIV (ADD* (SIMPLIFY ($DIFF $AQ
  827.                                                       (TRD-MSYMEVAL $X
  828.                                                                     '$X)))
  829.                                      (MUL* 2 $AP $AQ))
  830.                                (MUL* 2 (POWER $AQ (RREMAINDER 3 2)))))))
  831.      (COND (($FREEOF (TRD-MSYMEVAL $X '$X) (TRD-MSYMEVAL $Y '$Y) $D)
  832.             (SETQ $B1 (SIMPLIFY ($CC2 $D 1 (TRD-MSYMEVAL $Y '$Y) $Z))))
  833.            (T (RETURN NIL)))
  834.      (SETQ $METHOD '$XFORMTOCONSTCOEFF)
  835.      (RETURN
  836.       (SIMPLIFY
  837.        ($SUBSTITUTE (SIMPLIFY ($INTEGRATE (SIMPLIFY (LIST '(%SQRT) $AQ))
  838.                                           (TRD-MSYMEVAL $X '$X)))
  839.                     $Z
  840.                     $B1)))))
  841.    '$D
  842.    '$B1
  843.    '$Z
  844.    '$ALL)))
  845. (EVAL-WHEN (COMPILE EVAL LOAD)
  846.  (DEFPROP $VARP T TRANSLATED)
  847.  (ADD2LNC '$VARP $PROPS)
  848.  (DEFMTRFUN
  849.   ($VARP $ANY MDEFINE NIL NIL)
  850.   ($SOLN $%G%)
  851.   NIL
  852.   ((LAMBDA
  853.     ($Y1 $Y2 $Y3 $Y4 $WR $HEURISTIC $%K1 $%K2)
  854.     NIL
  855.     (PROG
  856.      NIL
  857.      (SETQ
  858.       $Y1
  859.       (SIMPLIFY
  860.        ($RATSIMP (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST)
  861.                                               (SIMPLIFY (LIST '(MEQUAL)
  862.                                                               $%K1
  863.                                                               1))
  864.                                               (SIMPLIFY (LIST '(MEQUAL)
  865.                                                               $%K2
  866.                                                               0)))
  867.                                         ($RHS $SOLN))))))
  868.      (SETQ
  869.       $Y2
  870.       (SIMPLIFY
  871.        ($RATSIMP (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST)
  872.                                               (SIMPLIFY (LIST '(MEQUAL)
  873.                                                               $%K1
  874.                                                               0))
  875.                                               (SIMPLIFY (LIST '(MEQUAL)
  876.                                                               $%K2
  877.                                                               1)))
  878.                                         ($RHS $SOLN))))))
  879.      (SETQ $WR (ADD* (MUL* $Y1 (SIMPLIFY ($DIFF $Y2 (TRD-MSYMEVAL $X '$X))))
  880.                      (*MMINUS (MUL* $Y2
  881.                                     (SIMPLIFY ($DIFF $Y1
  882.                                                      (TRD-MSYMEVAL $X
  883.                                                                    '$X)))))))
  884.      (COND ((LIKE $WR 0)
  885.             (RETURN NIL)))
  886.      (COND ((AND (LIKE (TRD-MSYMEVAL $METHOD '$METHOD) '$CONSTCOEFF)
  887.                  (NOT ($FREEOF '%SIN $WR))
  888.                  (NOT ($FREEOF '%COS $WR)))
  889.             (SETQ $HEURISTIC T)
  890.             (SETQ $WR (SIMPLIFY ($RATSIMP (SIMPLIFY ($TRIGREDUCE $WR)))))))
  891.      (SETQ $Y3 (SIMPLIFY ($RATSIMP (DIV (MUL* $Y1
  892.                                               (TRD-MSYMEVAL $%G% '$%G%))
  893.                                         $WR))))
  894.      (SETQ $Y4 (SIMPLIFY ($RATSIMP (DIV (MUL* $Y2
  895.                                               (TRD-MSYMEVAL $%G% '$%G%))
  896.                                         $WR))))
  897.      (SETQ
  898.       $YP
  899.       (SIMPLIFY
  900.        ($RATSIMP
  901.         (ADD* (MUL* $Y2 (SIMPLIFY ($INTEGRATE $Y3 (TRD-MSYMEVAL $X '$X))))
  902.               (*MMINUS (MUL* $Y1
  903.                              (SIMPLIFY ($INTEGRATE $Y4
  904.                                                    (TRD-MSYMEVAL $X
  905.                                                                  '$X)))))))))
  906.      (COND
  907.       ((LIKE $HEURISTIC T)
  908.        (SETQ
  909.         $YP
  910.         (SIMPLIFY ($RATSIMP (SIMPLIFY ($TRIGREDUCE (TRD-MSYMEVAL $YP
  911.                                                                  '$YP))))))))
  912.      (SETQ $METHOD '$VARIATIONOFPARAMETERS)
  913.      (RETURN (SIMPLIFY (LIST '(MEQUAL)
  914.                              (TRD-MSYMEVAL $Y '$Y)
  915.                              (ADD* ($RHS $SOLN) (TRD-MSYMEVAL $YP '$YP)))))))
  916.    '$Y1
  917.    '$Y2
  918.    '$Y3
  919.    '$Y4
  920.    '$WR
  921.    NIL
  922.    '$%K1
  923.    '$%K2)))
  924. (EVAL-WHEN (COMPILE EVAL LOAD)
  925.  (DEFPROP $REDUCE T TRANSLATED)
  926.  (ADD2LNC '$REDUCE $PROPS)
  927.  (DEFMTRFUN
  928.   ($REDUCE $ANY MDEFINE NIL NIL)
  929.   ($EQ)
  930.   NIL
  931.   ((LAMBDA
  932.     ($B1 $QQ)
  933.     NIL
  934.     (PROG
  935.      NIL
  936.      (SETQ
  937.       $B1
  938.       (SIMPLIFY
  939.        ($SUBSTITUTE
  940.         (LIST '(MLIST)
  941.               (SIMPLIFY (LIST '(MEQUAL)
  942.                               (SIMPLIFY `((%DERIVATIVE) ,
  943.                                           (TRD-MSYMEVAL $Y '$Y) ,
  944.                                           (TRD-MSYMEVAL $X '$X) 2))
  945.                               $QQ))
  946.               (SIMPLIFY (LIST '(MEQUAL)
  947.                               (SIMPLIFY `((%DERIVATIVE) ,
  948.                                           (TRD-MSYMEVAL $Y '$Y) ,
  949.                                           (TRD-MSYMEVAL $X '$X)))
  950.                               $QQ)))
  951.         $EQ)))
  952.      (COND (($FREEOF (TRD-MSYMEVAL $Y '$Y) $B1)
  953.             (RETURN (SIMPLIFY ($NLX $EQ)))))
  954.      (RETURN (COND (($FREEOF (TRD-MSYMEVAL $X '$X) $B1)
  955.                     (RETURN (SIMPLIFY ($NLY $EQ))))
  956.                    (T (RETURN NIL))))))
  957.    '$B1
  958.    '$QQ)))
  959. (EVAL-WHEN (COMPILE EVAL LOAD)
  960.  (DEFPROP $NLX T TRANSLATED)
  961.  (ADD2LNC '$NLX $PROPS)
  962.  (DEFMTRFUN
  963.   ($NLX $ANY MDEFINE NIL NIL)
  964.   ($EQ)
  965.   NIL
  966.   ((LAMBDA
  967.     ($DE $B $A1 $V $%K1 $%C)
  968.     NIL
  969.     (PROG
  970.      NIL
  971.      (SETQ
  972.       $DE
  973.       (SIMPLIFY
  974.        ($SUBSTITUTE
  975.         (LIST '(MLIST)
  976.               (SIMPLIFY (LIST '(MEQUAL)
  977.                               (SIMPLIFY `((%DERIVATIVE) ,
  978.                                           (TRD-MSYMEVAL $Y '$Y) ,
  979.                                           (TRD-MSYMEVAL $X '$X) 2))
  980.                               (SIMPLIFY `((%DERIVATIVE) ,$V ,
  981.                                           (TRD-MSYMEVAL $X '$X)))))
  982.               (SIMPLIFY (LIST '(MEQUAL)
  983.                               (SIMPLIFY `((%DERIVATIVE) ,
  984.                                           (TRD-MSYMEVAL $Y '$Y) ,
  985.                                           (TRD-MSYMEVAL $X '$X)))
  986.                               $V)))
  987.         $EQ)))
  988.      (COND ((LIKE (SETQ $B (SIMPLIFY ($ODE1A $DE $V (TRD-MSYMEVAL $X '$X))))
  989.                   NIL)
  990.             (RETURN NIL)))
  991.      (SETQ
  992.       $A1
  993.       (SIMPLIFY
  994.        ($SUBSTITUTE
  995.         (LIST '(MLIST)
  996.               (SIMPLIFY (LIST '(MEQUAL)
  997.                               $V
  998.                               (SIMPLIFY `((%DERIVATIVE) ,
  999.                                           (TRD-MSYMEVAL $Y '$Y) ,
  1000.                                           (TRD-MSYMEVAL $X '$X)))))
  1001.               (SIMPLIFY (LIST '(MEQUAL) $%C $%K1)))
  1002.         $B)))
  1003.      (RETURN
  1004.       (COND (($FTEST (SIMPLIFY ($NLXY $A1
  1005.                                       (SIMPLIFY `((%DERIVATIVE) ,
  1006.                                                   (TRD-MSYMEVAL $Y '$Y)
  1007.                                                   ,(TRD-MSYMEVAL $X
  1008.                                                                  '$X))))))
  1009.              (SETQ $METHOD '$FREEOFY)
  1010.              (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  1011.             (T (RETURN NIL))))))
  1012.    '$DE
  1013.    '$B
  1014.    '$A1
  1015.    '$V
  1016.    '$%K1
  1017.    '$%C)))
  1018. (EVAL-WHEN (COMPILE EVAL LOAD)
  1019.  (DEFPROP $NLY T TRANSLATED)
  1020.  (ADD2LNC '$NLY $PROPS)
  1021.  (DEFMTRFUN
  1022.   ($NLY $ANY MDEFINE NIL NIL)
  1023.   ($EQ)
  1024.   NIL
  1025.   ((LAMBDA
  1026.     ($DE $B $A1 $YZ $V $%C $%K1)
  1027.     NIL
  1028.     (PROG
  1029.      NIL
  1030.      (SETQ
  1031.       $DE
  1032.       (SIMPLIFY
  1033.        ($SUBSTITUTE
  1034.         (LIST '(MLIST)
  1035.               (SIMPLIFY (LIST '(MEQUAL)
  1036.                               (SIMPLIFY `((%DERIVATIVE) ,
  1037.                                           (TRD-MSYMEVAL $Y '$Y) ,
  1038.                                           (TRD-MSYMEVAL $X '$X) 2))
  1039.                               (MUL* $V
  1040.                                     (SIMPLIFY `((%DERIVATIVE) ,$V ,$YZ)))))
  1041.               (SIMPLIFY (LIST '(MEQUAL)
  1042.                               (SIMPLIFY `((%DERIVATIVE) ,
  1043.                                           (TRD-MSYMEVAL $Y '$Y) ,
  1044.                                           (TRD-MSYMEVAL $X '$X)))
  1045.                               $V))
  1046.               (SIMPLIFY (LIST '(MEQUAL) (TRD-MSYMEVAL $Y '$Y) $YZ)))
  1047.         $EQ)))
  1048.      (COND ((LIKE (SETQ $B (SIMPLIFY ($ODE1A $DE $V $YZ)))
  1049.                   NIL)
  1050.             (RETURN NIL)))
  1051.      (SETQ
  1052.       $A1
  1053.       (SIMPLIFY
  1054.        ($SUBSTITUTE
  1055.         (LIST '(MLIST)
  1056.               (SIMPLIFY (LIST '(MEQUAL)
  1057.                               $V
  1058.                               (SIMPLIFY `((%DERIVATIVE) ,
  1059.                                           (TRD-MSYMEVAL $Y '$Y) ,
  1060.                                           (TRD-MSYMEVAL $X '$X)))))
  1061.               (SIMPLIFY (LIST '(MEQUAL) $YZ (TRD-MSYMEVAL $Y '$Y)))
  1062.               (SIMPLIFY (LIST '(MEQUAL) $%C $%K1)))
  1063.         $B)))
  1064.      (RETURN
  1065.       (COND (($FTEST (SIMPLIFY ($NLXY $A1
  1066.                                       (SIMPLIFY `((%DERIVATIVE) ,
  1067.                                                   (TRD-MSYMEVAL $Y '$Y)
  1068.                                                   ,(TRD-MSYMEVAL $X
  1069.                                                                  '$X))))))
  1070.              (SETQ $METHOD '$FREEOFX)
  1071.              (RETURN (TRD-MSYMEVAL $%Q% '$%Q%)))
  1072.             (T (RETURN NIL))))))
  1073.    '$DE
  1074.    '$B
  1075.    '$A1
  1076.    '$YZ
  1077.    '$V
  1078.    '$%C
  1079.    '$%K1)))
  1080. (EVAL-WHEN (COMPILE EVAL LOAD)
  1081.  (DEFPROP $NLXY T TRANSLATED)
  1082.  (ADD2LNC '$NLXY $PROPS)
  1083.  (DEFMTRFUN
  1084.   ($NLXY $ANY MDEFINE NIL NIL)
  1085.   ($EQ $DE)
  1086.   NIL
  1087.   ((LAMBDA
  1088.     ($PROGRAMMODE $EQ1 $%K2 $%C)
  1089.     NIL
  1090.     (PROG
  1091.      NIL
  1092.      (SETQ $EQ1 (SIMPLIFY ($SOLVE $EQ $DE)))
  1093.      (SETQ
  1094.       $EQ1
  1095.       (MAPLIST_TR
  1096.        (M-TLAMBDA&ENV
  1097.         (($ZZ) ($%K2 $%C))
  1098.         NIL
  1099.         (COND (($FTEST (SIMPLIFY ($ODE1A $ZZ
  1100.                                          (TRD-MSYMEVAL $Y '$Y)
  1101.                                          (TRD-MSYMEVAL $X '$X))))
  1102.                (SIMPLIFY ($SUBSTITUTE $%K2
  1103.                                       $%C
  1104.                                       (TRD-MSYMEVAL $%Q% '$%Q%))))))
  1105.        $EQ1))
  1106.      (RETURN (COND ((EQL ($LENGTH $EQ1) 1)
  1107.                     (RETURN (SIMPLIFY ($FIRST $EQ1))))
  1108.                    (T (RETURN $EQ1))))))
  1109.    T
  1110.    '$EQ1
  1111.    '$%K2
  1112.    '$%C)))
  1113. (EVAL-WHEN (COMPILE EVAL LOAD)
  1114.  (DEFPROP $PTTEST T TRANSLATED)
  1115.  (ADD2LNC '$PTTEST $PROPS)
  1116.  (DEFMTRFUN
  1117.   ($PTTEST $ANY MDEFINE NIL NIL)
  1118.   ($A)
  1119.   NIL
  1120.   ((LAMBDA ($A1 $A2 $A3)
  1121.      NIL
  1122.      (PROG NIL
  1123.            (COND ((LIKE (SETQ $A1 (SIMPLIFY ($RATSIMP $A)))
  1124.                         0)
  1125.                   (RETURN NIL)))
  1126.            (SETQ $A1 (SIMPLIFY ($EXPAND (DIV 1 $A1))))
  1127.            (COND ((LIKE (SETQ $A2 (SIMPLIFY ($COEFF $A1
  1128.                                                     (TRD-MSYMEVAL $X '$X)
  1129.                                                     1)))
  1130.                         0)
  1131.                   (RETURN NIL)))
  1132.            (COND ((NOT ($FREEOF (TRD-MSYMEVAL $X '$X) $A2))
  1133.                   (RETURN NIL)))
  1134.            (SETQ $A3 (SIMPLIFY ($COEFF $A1 (TRD-MSYMEVAL $X '$X) 0)))
  1135.            (RETURN (COND ((NOT (LIKE $A1
  1136.                                      (ADD* (MUL* $A2
  1137.                                                  (TRD-MSYMEVAL $X '$X))
  1138.                                            $A3)))
  1139.                           (RETURN NIL))
  1140.                          (T (RETURN (DIV (*MMINUS $A3) $A2)))))))
  1141.    '$A1
  1142.    '$A2
  1143.    '$A3)))
  1144. (EVAL-WHEN (COMPILE EVAL LOAD)
  1145.  (DEFPROP $EULER2 T TRANSLATED)
  1146.  (ADD2LNC '$EULER2 $PROPS)
  1147.  (DEFMTRFUN
  1148.   ($EULER2 $ANY MDEFINE NIL NIL)
  1149.   ($A $B)
  1150.   NIL
  1151.   ((LAMBDA
  1152.     ($DC $RP $IP $ALPHA $BETA $SIGN $RADEXPAND $%K1 $%K2 $POS $ZERO)
  1153.     NIL
  1154.     (PROG
  1155.      NIL
  1156.      (COND
  1157.       ((NOT
  1158.         ($FREEOF
  1159.          (TRD-MSYMEVAL $X '$X)
  1160.          (TRD-MSYMEVAL $Y '$Y)
  1161.          (SETQ
  1162.           $BETA
  1163.           (SIMPLIFY
  1164.            ($RATSIMP (MUL* $B
  1165.                            (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1166.                                         (*MMINUS (TRD-MSYMEVAL $PT
  1167.                                                                '$PT)))
  1168.                                   2)))))))
  1169.        (RETURN NIL)))
  1170.      (SETQ $METHOD '$EULER)
  1171.      (SETQ $ALPHA (MUL* $A
  1172.                         (ADD* (TRD-MSYMEVAL $X '$X)
  1173.                               (*MMINUS (TRD-MSYMEVAL $PT '$PT)))))
  1174.      (SETQ $DC (SIMPLIFY ($RATSIMP (ADD* (POWER (ADD* $ALPHA -1) 2)
  1175.                                          (*MMINUS (MUL* 4 $BETA))))))
  1176.      (SETQ $RP (SIMPLIFY ($RATSIMP (DIV (*MMINUS (ADD* $ALPHA -1)) 2))))
  1177.      (SETQ $SIGN (SIMPLIFY ($ASKSIGN $DC)))
  1178.      (COND
  1179.       ((LIKE $SIGN $ZERO)
  1180.        (RETURN
  1181.         (SIMPLIFY
  1182.          (LIST
  1183.           '(MEQUAL)
  1184.           (TRD-MSYMEVAL $Y '$Y)
  1185.           (MUL*
  1186.            (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1187.                         (*MMINUS (TRD-MSYMEVAL $PT '$PT)))
  1188.                   $RP)
  1189.            (ADD*
  1190.             $%K1
  1191.             (MUL*
  1192.              $%K2
  1193.              (SIMPLIFY (LIST '(%LOG)
  1194.                              (ADD* (TRD-MSYMEVAL $X '$X)
  1195.                                    (*MMINUS (TRD-MSYMEVAL $PT
  1196.                                                           '$PT)))))))))))))
  1197.      (COND
  1198.       ((LIKE $SIGN $POS)
  1199.        (SETQ $IP (DIV (SIMPLIFY (LIST '(%SQRT) $DC)) 2))
  1200.        (RETURN
  1201.         (SIMPLIFY
  1202.          (LIST '(MEQUAL)
  1203.                (TRD-MSYMEVAL $Y '$Y)
  1204.                (ADD* (MUL* $%K1
  1205.                            (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1206.                                         (*MMINUS (TRD-MSYMEVAL $PT
  1207.                                                                '$PT)))
  1208.                                   (ADD* $RP $IP)))
  1209.                      (MUL* $%K2
  1210.                            (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1211.                                         (*MMINUS (TRD-MSYMEVAL $PT
  1212.                                                                '$PT)))
  1213.                                   (ADD* $RP (*MMINUS $IP))))))))))
  1214.      (SETQ $DC (*MMINUS $DC))
  1215.      (SETQ $IP (DIV (SIMPLIFY (LIST '(%SQRT) $DC)) 2))
  1216.      (RETURN
  1217.       (SIMPLIFY
  1218.        (LIST
  1219.         '(MEQUAL)
  1220.         (TRD-MSYMEVAL $Y '$Y)
  1221.         (MUL*
  1222.          (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1223.                       (*MMINUS (TRD-MSYMEVAL $PT '$PT)))
  1224.                 $RP)
  1225.          (ADD*
  1226.           (MUL*
  1227.            $%K1
  1228.            (SIMPLIFY
  1229.             (LIST
  1230.              '(%SIN)
  1231.              (MUL*
  1232.               $IP
  1233.               (SIMPLIFY (LIST '(%LOG)
  1234.                               (ADD* (TRD-MSYMEVAL $X '$X)
  1235.                                     (*MMINUS (TRD-MSYMEVAL $PT
  1236.                                                            '$PT)))))))))
  1237.           (MUL*
  1238.            $%K2
  1239.            (SIMPLIFY
  1240.             (LIST
  1241.              '(%COS)
  1242.              (MUL*
  1243.               $IP
  1244.               (SIMPLIFY
  1245.                (LIST '(%LOG)
  1246.                      (ADD* (TRD-MSYMEVAL $X '$X)
  1247.                            (*MMINUS (TRD-MSYMEVAL $PT '$PT))))))))))))))))
  1248.    '$DC
  1249.    '$RP
  1250.    '$IP
  1251.    '$ALPHA
  1252.    '$BETA
  1253.    '$SIGN
  1254.    NIL
  1255.    '$%K1
  1256.    '$%K2
  1257.    '$POS
  1258.    '$ZERO)))
  1259. (EVAL-WHEN (COMPILE EVAL LOAD)
  1260.  (DEFPROP $BESSEL2 T TRANSLATED)
  1261.  (ADD2LNC '$BESSEL2 $PROPS)
  1262.  (DEFMTRFUN
  1263.   ($BESSEL2 $ANY MDEFINE NIL NIL)
  1264.   ($A $B)
  1265.   NIL
  1266.   ((LAMBDA
  1267.     ($NU $B1 $INTP $RADEXPAND $%K1 $%Y $%K2 $%J)
  1268.     NIL
  1269.     (PROG
  1270.      NIL
  1271.      (COND
  1272.       ((NOT
  1273.         ($FREEOF
  1274.          (TRD-MSYMEVAL $X '$X)
  1275.          (TRD-MSYMEVAL $Y '$Y)
  1276.          (SETQ
  1277.           $B1
  1278.           (SIMPLIFY
  1279.            ($RATSIMP (MUL* (ADD* 1 (*MMINUS $B))
  1280.                            (POWER (ADD* (TRD-MSYMEVAL $X '$X)
  1281.                                         (*MMINUS (TRD-MSYMEVAL $PT
  1282.                                                                '$PT)))
  1283.                                   2)))))))
  1284.        (RETURN NIL)))
  1285.      (COND
  1286.       ((NOT
  1287.         (LIKE
  1288.          (SIMPLIFY ($RATSIMP (MUL* $A
  1289.                                    (ADD* (TRD-MSYMEVAL $X '$X)
  1290.                                          (*MMINUS (TRD-MSYMEVAL $PT
  1291.                                                                 '$PT))))))
  1292.          1))
  1293.        (RETURN NIL)))
  1294.      (SETQ $NU (SIMPLIFY (LIST '(%SQRT) $B1)))
  1295.      (SETQ $METHOD '$BESSEL)
  1296.      (COND
  1297.       ((LIKE $NU (RREMAINDER 1 2))
  1298.        (RETURN
  1299.         (SIMPLIFY
  1300.          (LIST
  1301.           '(MEQUAL)
  1302.           (TRD-MSYMEVAL $Y '$Y)
  1303.           (DIV
  1304.            (ADD*
  1305.             (MUL*
  1306.              $%K1
  1307.              (SIMPLIFY (LIST '(%SIN)
  1308.                              (ADD* (TRD-MSYMEVAL $X '$X)
  1309.                                    (*MMINUS (TRD-MSYMEVAL $PT '$PT))))))
  1310.             (MUL*
  1311.              $%K2
  1312.              (SIMPLIFY (LIST '(%COS)
  1313.                              (ADD* (TRD-MSYMEVAL $X '$X)
  1314.                                    (*MMINUS (TRD-MSYMEVAL $PT
  1315.                                                           '$PT)))))))
  1316.            (SIMPLIFY (LIST '(%SQRT)
  1317.                            (ADD* (TRD-MSYMEVAL $X '$X)
  1318.                                  (*MMINUS (TRD-MSYMEVAL $PT '$PT)))))))))))
  1319.      (COND ((IS-BOOLE-CHECK (SIMPLIFY ($FEATUREP $NU '$INTEGER)))
  1320.             (SETQ $INTP '$Y))
  1321.            (($NUMBERP $NU)
  1322.             (SETQ $INTP '$N)))
  1323.      $LOOP
  1324.      (COND
  1325.       ((NOT (OR (LIKE $INTP '$Y)
  1326.                 (LIKE $INTP '$N)))
  1327.        (SETQ $INTP (SIMPLIFY ($READONLY '|&Is|
  1328.                                         $NU
  1329.                                         '|&an integer?  Type Y or N.|)))
  1330.        (GO $LOOP)))
  1331.      (COND
  1332.       ((LIKE $INTP '$Y)
  1333.        (RETURN
  1334.         (SIMPLIFY
  1335.          (LIST
  1336.           '(MEQUAL)
  1337.           (TRD-MSYMEVAL $Y '$Y)
  1338.           (ADD*
  1339.            (MUL*
  1340.             $%K1
  1341.             (SIMPLIFY
  1342.              (MAPPLY (MAREF $%J $NU)
  1343.                      (LIST (ADD* (TRD-MSYMEVAL $X '$X)
  1344.                                  (*MMINUS (TRD-MSYMEVAL $PT '$PT))))
  1345.                      '(($%J ARRAY) $NU))))
  1346.            (MUL*
  1347.             $%K2
  1348.             (SIMPLIFY
  1349.              (MAPPLY (MAREF $%Y $NU)
  1350.                      (LIST (ADD* (TRD-MSYMEVAL $X '$X)
  1351.                                  (*MMINUS (TRD-MSYMEVAL $PT '$PT))))
  1352.                      '(($%Y ARRAY) $NU))))))))))
  1353.      (RETURN
  1354.       (SIMPLIFY
  1355.        (LIST
  1356.         '(MEQUAL)
  1357.         (TRD-MSYMEVAL $Y '$Y)
  1358.         (ADD*
  1359.          (MUL*
  1360.           $%K1
  1361.           (SIMPLIFY (MAPPLY (MAREF $%J $NU)
  1362.                             (LIST (ADD* (TRD-MSYMEVAL $X '$X)
  1363.                                         (*MMINUS (TRD-MSYMEVAL $PT
  1364.                                                                '$PT))))
  1365.                             '(($%J ARRAY) $NU))))
  1366.          (MUL*
  1367.           $%K2
  1368.           (SIMPLIFY
  1369.            (MAPPLY (MAREF $%J (*MMINUS $NU))
  1370.                    (LIST (ADD* (TRD-MSYMEVAL $X '$X)
  1371.                                (*MMINUS (TRD-MSYMEVAL $PT '$PT))))
  1372.                    '(($%J ARRAY) ((MMINUS) $NU)))))))))))
  1373.    '$NU
  1374.    '$B1
  1375.    '$INTP
  1376.    '$ALL
  1377.    '$%K1
  1378.    '$%Y
  1379.    '$%K2
  1380.    '$%J)))
  1381. (EVAL-WHEN (COMPILE EVAL LOAD)
  1382.  (DEFPROP $IC1 T TRANSLATED)
  1383.  (ADD2LNC '$IC1 $PROPS)
  1384.  (DEFMTRFUN
  1385.   ($IC1 $ANY MDEFINE NIL NIL)
  1386.   ($SOLN $XC $YC)
  1387.   NIL
  1388.   ((LAMBDA
  1389.     ($%C)
  1390.     NIL
  1391.     (PROGN
  1392.      (SIMPLIFY ($NOTEQN $XC))
  1393.      (SIMPLIFY ($NOTEQN $YC))
  1394.      (SIMPLIFY ($BOUNDTEST '$%C $%C))
  1395.      (SIMPLIFY
  1396.       ($RATSIMP
  1397.        (SIMPLIFY
  1398.         ($SUBSTITUTE
  1399.          (LIST
  1400.           '(MLIST)
  1401.           (SIMPLIFY
  1402.            (LIST
  1403.             '(MEQUAL)
  1404.             '$%C
  1405.             ($RHS
  1406.              (SIMPLIFY
  1407.               ($SOLVE1 (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST)
  1408.                                                     $XC
  1409.                                                     $YC)
  1410.                                               $SOLN))
  1411.                        $%C))))))
  1412.          $SOLN))))))
  1413.    '$%C)))
  1414. (EVAL-WHEN (COMPILE EVAL LOAD)
  1415.  (DEFPROP $BC2 T TRANSLATED)
  1416.  (ADD2LNC '$BC2 $PROPS)
  1417.  (DEFMTRFUN
  1418.   ($BC2 $ANY MDEFINE NIL NIL)
  1419.   ($SOLN $XA $YA $XB $YB)
  1420.   NIL
  1421.   ((LAMBDA
  1422.     ($PROGRAMMODE $BACKSUBST $SINGSOLVE $TEMP $%K1 $%K2)
  1423.     NIL
  1424.     (PROG
  1425.      NIL
  1426.      (SIMPLIFY ($NOTEQN $XA))
  1427.      (SIMPLIFY ($NOTEQN $YA))
  1428.      (SIMPLIFY ($NOTEQN $XB))
  1429.      (SIMPLIFY ($NOTEQN $YB))
  1430.      (SIMPLIFY ($BOUNDTEST '$%K1 $%K1))
  1431.      (SIMPLIFY ($BOUNDTEST '$%K2 $%K2))
  1432.      (SETQ
  1433.       $TEMP
  1434.       (MAPLIST_TR
  1435.        (M-TLAMBDA&ENV (($ZZ) ($SOLN))
  1436.                       NIL
  1437.                       (SIMPLIFY ($SUBSTITUTE $ZZ $SOLN)))
  1438.        (SIMPLIFY ($SOLVE (LIST '(MLIST)
  1439.                                (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST)
  1440.                                                             $XA
  1441.                                                             $YA)
  1442.                                                       $SOLN))
  1443.                                (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST)
  1444.                                                             $XB
  1445.                                                             $YB)
  1446.                                                       $SOLN)))
  1447.                          (LIST '(MLIST) $%K1 $%K2)))))
  1448.      (RETURN (COND ((EQL ($LENGTH $TEMP) 1)
  1449.                     (RETURN (SIMPLIFY ($FIRST $TEMP))))
  1450.                    (T (RETURN $TEMP))))))
  1451.    T
  1452.    T
  1453.    T
  1454.    '$TEMP
  1455.    '$%K1
  1456.    '$%K2)))
  1457. (EVAL-WHEN (COMPILE EVAL LOAD)
  1458.  (DEFPROP $IC2 T TRANSLATED)
  1459.  (ADD2LNC '$IC2 $PROPS)
  1460.  (DEFMTRFUN
  1461.   ($IC2 $ANY MDEFINE NIL NIL)
  1462.   ($SOLN $XA $YA $DYA)
  1463.   NIL
  1464.   ((LAMBDA
  1465.     ($PROGRAMMODE $BACKSUBST $SINGSOLVE $TEMP $%K2 $%K1)
  1466.     NIL
  1467.     (PROG
  1468.      NIL
  1469.      (SIMPLIFY ($NOTEQN $XA))
  1470.      (SIMPLIFY ($NOTEQN $YA))
  1471.      (SIMPLIFY ($NOTEQN $DYA))
  1472.      (SIMPLIFY ($BOUNDTEST '$%K1 $%K1))
  1473.      (SIMPLIFY ($BOUNDTEST '$%K2 $%K2))
  1474.      (SETQ $TEMP (ADD* ($LHS $SOLN) (*MMINUS ($RHS $SOLN))))
  1475.      (SETQ
  1476.       $TEMP
  1477.       (MAPLIST_TR
  1478.        (M-TLAMBDA&ENV (($ZZ) ($SOLN))
  1479.                       NIL
  1480.                       (SIMPLIFY ($SUBSTITUTE $ZZ $SOLN)))
  1481.        (SIMPLIFY
  1482.         ($SOLVE
  1483.          (LIST
  1484.           '(MLIST)
  1485.           (SIMPLIFY ($SUBSTITUTE (LIST '(MLIST) $XA $YA) $SOLN))
  1486.           (SIMPLIFY
  1487.            ($SUBSTITUTE
  1488.             (LIST '(MLIST) $DYA $XA)
  1489.             (SIMPLIFY
  1490.              (LIST
  1491.               '(MEQUAL)
  1492.               ($LHS $DYA)
  1493.               (DIV
  1494.                (*MMINUS
  1495.                 (SIMPLIFY
  1496.                  ($SUBSTITUTE 0
  1497.                               ($LHS $DYA)
  1498.                               (SIMPLIFY ($DIFF $TEMP ($LHS $XA))))))
  1499.                (SIMPLIFY ($DIFF $TEMP ($LHS $YA)))))))))
  1500.          (LIST '(MLIST) $%K1 $%K2)))))
  1501.      (RETURN (COND ((EQL ($LENGTH $TEMP) 1)
  1502.                     (RETURN (SIMPLIFY ($FIRST $TEMP))))
  1503.                    (T (RETURN $TEMP))))))
  1504.    T
  1505.    T
  1506.    T
  1507.    '$TEMP
  1508.    '$%K2
  1509.    '$%K1)))
  1510. (EVAL-WHEN (COMPILE EVAL LOAD)
  1511.  (DEFPROP $NOTEQN T TRANSLATED)
  1512.  (ADD2LNC '$NOTEQN $PROPS)
  1513.  (DEFMTRFUN ($NOTEQN $ANY MDEFINE NIL NIL)
  1514.             ($X)
  1515.             NIL
  1516.             (COND ((OR ($ATOM (TRD-MSYMEVAL $X '$X))
  1517.                        (NOT (LIKE (SIMPLIFY ($INPART (TRD-MSYMEVAL $X '$X)
  1518.                                                      0))
  1519.                                   '&=)))
  1520.                    (DISPLAY-FOR-TR NIL NIL (TRD-MSYMEVAL $X '$X))
  1521.                    (DISPLAY-FOR-TR NIL NIL '|&Not an equation|)
  1522.                    (SIMPLIFY ($ERROR))))))
  1523. (EVAL-WHEN (COMPILE EVAL LOAD)
  1524.        (DEFPROP $BOUNDTEST T TRANSLATED)
  1525.        (ADD2LNC '$BOUNDTEST $PROPS)
  1526.        (DEFMTRFUN ($BOUNDTEST $ANY MDEFINE NIL NIL)
  1527.                   ($X $Y)
  1528.                   NIL
  1529.                   (COND ((NOT (LIKE (TRD-MSYMEVAL $X '$X)
  1530.                                     (TRD-MSYMEVAL $Y '$Y)))
  1531.                          (DISPLAY-FOR-TR NIL NIL (TRD-MSYMEVAL $X '$X))
  1532.                          (DISPLAY-FOR-TR NIL NIL '|&Must not be bound|)
  1533.                          (SIMPLIFY ($ERROR))))))
  1534. (EVAL-WHEN (COMPILE EVAL LOAD)
  1535.  (DEFPROP $FAILURE T TRANSLATED)
  1536.  (ADD2LNC '$FAILURE $PROPS)
  1537.  (DEFMTRFUN
  1538.   ($FAILURE $BOOLEAN MDEFINE NIL NIL)
  1539.   ($MSG $EQ)
  1540.   NIL
  1541.   ((LAMBDA
  1542.     ($YNEW)
  1543.     NIL
  1544.     (PROGN
  1545.      (COND ((NOT (IS-BOOLE-CHECK (STATUS $FEATURE &ODE)))
  1546.             (DISPLAY-FOR-TR T
  1547.                             NIL
  1548.                             (SIMPLIFY ($SUBSTITUTE (TRD-MSYMEVAL $YOLD
  1549.                                                                  '$YOLD)
  1550.                                                    $YNEW
  1551.                                                    $EQ)))
  1552.             (DISPLAY-FOR-TR NIL NIL $MSG)))
  1553.      NIL))
  1554.    '$YNEW)))
  1555. (EVAL-WHEN (load COMPILE) (MEVAL '(($REMOVE) $X $SPECIAL $Y $SPECIAL)))
  1556. (SETQ $MSG1 '|&Not a proper differential equation|)
  1557. (SETQ $MSG2 '|&First order equation not linear in y'|)
  1558.